/*-
 * Copyright (c) 2003, 2004 Lev Walkin <vlm@lionet.info>. All rights reserved.
 * Redistribution and modifications are permitted subject to BSD license.
 */
#include <BIT_STRING.h>
#include <asn_internal.h>

/*
 * BIT STRING basic type description.
 */
static ber_tlv_tag_t asn_DEF_BIT_STRING_tags[] = {
    (ASN_TAG_CLASS_UNIVERSAL | (3 << 2))};
static asn_OCTET_STRING_specifics_t asn_DEF_BIT_STRING_specs = {
    sizeof(BIT_STRING_t), offsetof(BIT_STRING_t, _asn_ctx), ASN_OSUBV_BIT};
asn_TYPE_descriptor_t asn_DEF_BIT_STRING = {
    "BIT STRING",
    "BIT_STRING",
    OCTET_STRING_free, /* Implemented in terms of OCTET STRING */
    BIT_STRING_print,
    BIT_STRING_constraint,
    OCTET_STRING_decode_ber, /* Implemented in terms of OCTET STRING */
    OCTET_STRING_encode_der, /* Implemented in terms of OCTET STRING */
    OCTET_STRING_decode_xer_binary,
    BIT_STRING_encode_xer,
    OCTET_STRING_decode_uper, /* Unaligned PER decoder */
    OCTET_STRING_encode_uper, /* Unaligned PER encoder */
    OCTET_STRING_decode_aper, /* Aligned PER decoder */
    OCTET_STRING_encode_aper, /* Aligned PER encoder */
    OCTET_STRING_compare,
    0, /* Use generic outmost tag fetcher */
    asn_DEF_BIT_STRING_tags,
    sizeof(asn_DEF_BIT_STRING_tags) / sizeof(asn_DEF_BIT_STRING_tags[0]),
    asn_DEF_BIT_STRING_tags, /* Same as above */
    sizeof(asn_DEF_BIT_STRING_tags) / sizeof(asn_DEF_BIT_STRING_tags[0]),
    0, /* No PER visible constraints */
    0,
    0, /* No members */
    &asn_DEF_BIT_STRING_specs};

/*
 * BIT STRING generic constraint.
 */
int BIT_STRING_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
                          asn_app_constraint_failed_f *ctfailcb,
                          void *app_key) {
  const BIT_STRING_t *st = (const BIT_STRING_t *)sptr;

  if (st && st->buf) {
    if ((st->size == 0 && st->bits_unused) || st->bits_unused < 0 ||
        st->bits_unused > 7) {
      _ASN_CTFAIL(app_key, td, sptr, "%s: invalid padding byte (%s:%d)",
                  td->name, __FILE__, __LINE__);
      return -1;
    }
  } else {
    _ASN_CTFAIL(app_key, td, sptr, "%s: value not given (%s:%d)", td->name,
                __FILE__, __LINE__);
    return -1;
  }

  return 0;
}

static char *_bit_pattern[16] = {"0000", "0001", "0010", "0011", "0100", "0101",
                                 "0110", "0111", "1000", "1001", "1010", "1011",
                                 "1100", "1101", "1110", "1111"};

asn_enc_rval_t BIT_STRING_encode_xer(asn_TYPE_descriptor_t *td, void *sptr,
                                     int ilevel, enum xer_encoder_flags_e flags,
                                     asn_app_consume_bytes_f *cb,
                                     void *app_key) {
  asn_enc_rval_t er;
  char scratch[128];
  char *p = scratch;
  char *scend = scratch + (sizeof(scratch) - 10);
  const BIT_STRING_t *st = (const BIT_STRING_t *)sptr;
  int xcan = (flags & XER_F_CANONICAL);
  uint8_t *buf;
  uint8_t *end;

  if (!st || !st->buf) _ASN_ENCODE_FAILED;

  er.encoded = 0;

  buf = st->buf;
  end = buf + st->size - 1; /* Last byte is special */

  /*
   * Binary dump
   */
  for (; buf < end; buf++) {
    int v = *buf;
    int nline = xcan ? 0 : (((buf - st->buf) % 8) == 0);
    if (p >= scend || nline) {
      er.encoded += p - scratch;
      _ASN_CALLBACK(scratch, p - scratch);
      p = scratch;
      if (nline) _i_ASN_TEXT_INDENT(1, ilevel);
    }
    memcpy(p + 0, _bit_pattern[v >> 4], 4);
    memcpy(p + 4, _bit_pattern[v & 0x0f], 4);
    p += 8;
  }

  if (!xcan && ((buf - st->buf) % 8) == 0) _i_ASN_TEXT_INDENT(1, ilevel);
  er.encoded += p - scratch;
  _ASN_CALLBACK(scratch, p - scratch);
  p = scratch;

  if (buf == end) {
    int v = *buf;
    int ubits = st->bits_unused;
    int i;
    for (i = 7; i >= ubits; i--) *p++ = (v & (1 << i)) ? 0x31 : 0x30;
    er.encoded += p - scratch;
    _ASN_CALLBACK(scratch, p - scratch);
  }

  if (!xcan) _i_ASN_TEXT_INDENT(1, ilevel - 1);

  _ASN_ENCODED_OK(er);
cb_failed:
  _ASN_ENCODE_FAILED;
}

/*
 * BIT STRING specific contents printer.
 */
int BIT_STRING_print(asn_TYPE_descriptor_t *td, const void *sptr, int ilevel,
                     asn_app_consume_bytes_f *cb, void *app_key) {
  static const char *h2c = "0123456789ABCDEF";
  char scratch[64];
  const BIT_STRING_t *st = (const BIT_STRING_t *)sptr;
  uint8_t *buf;
  uint8_t *end;
  char *p = scratch;

  (void)td; /* Unused argument */

  if (!st || !st->buf) return (cb("<absent>", 8, app_key) < 0) ? -1 : 0;

  ilevel++;
  buf = st->buf;
  end = buf + st->size;

  /*
   * Hexadecimal dump.
   */
  for (; buf < end; buf++) {
    if ((buf - st->buf) % 16 == 0 && (st->size > 16) && buf != st->buf) {
      _i_INDENT(1);
      /* Dump the string */
      if (cb(scratch, p - scratch, app_key) < 0) return -1;
      p = scratch;
    }
    *p++ = h2c[*buf >> 4];
    *p++ = h2c[*buf & 0x0F];
    *p++ = 0x20;
  }

  if (p > scratch) {
    p--; /* Eat the tailing space */

    if ((st->size > 16)) {
      _i_INDENT(1);
    }

    /* Dump the incomplete 16-bytes row */
    if (cb(scratch, p - scratch, app_key) < 0) return -1;
  }

  return 0;
}
